// enum Direction {
//     Up = "UP",
//     Down = "DOWN",
//     Left = "LEFT",
//     Right = "RIGHT",
// }
// console.log(Direction.Up)

// interface objTBase{
//     id:number;
//     name:string
// }

// interface objType extends  objTBase{
//     test :[];
// }
// let obj:objType ={
//     id:1,
//     name:"222",
//     test:[]
// }

// interface responseBase<T>{
//     data:T
// }

// interface SearchFunc {
//     (source: string, subString: string): boolean;   //定义函数约束
//   }

// let mySearch: SearchFunc;
// mySearch = function(source: string, subString: string) {
//    let result = source.search(subString);
//     return false
// }

// interface ioi {
//     (name:string,id:number):string
// }

// let dd:ioi=(d )=>{
//     return ""
// }

// dd("585",5)

// interface StringArray {
//   da: string,
//    va: string;
//   }
  
//   let myArray: StringArray;
//   myArray ={da:"55",va:"656"}
  
//   let myStr: string = myArray["da"];
//   console.log(myStr)

// interface NumberDictionary {
//     [index:string]: number;
//     id: number;    // 可以，length是number类型
//     name: number       // 错误，`name`的类型与索引类型返回值的类型不匹配
//   }
// let ss:NumberDictionary={
//     id:1,
//     name:2,
//     1:1,
//     ddd:1,
// }
// class Animal {
//     name: string;
// }
// class Dog {
//     breed: string;
// }

// // 错误：使用数值型的字符串索引，有时会得到完全不同的Animal!
// interface NotOkay {
//     [x: string]: Animal;
//     [x: string]: Dog;
// }


// interface Shape {
//     color: string;
// }

// interface Square extends Shape {
//     sideLength: number;
// }

// let square = <Square>{};
// square.color = "blue";



// interface Counter {
//     (start: number): string;
//     interval: number;
//     reset(): void;
// }

// function getCounter(): Counter {
//     let counter = <Counter> function (start: number) { };
//     counter.interval = 123;
//     counter.reset = function () { };
//     return counter;
// }

// let c = getCounter();
// c(10);
// c.reset();
// c.interval = 5.0;


// abstract class Animal {
//     abstract makeSound(): void;
//     move(): void {
//         console.log('roaming the earch...');
//     }
// }

// let myAdd = function(x:number, y:number):number { return x + y; };

// myAdd(1,2)

// let deck = {
//     suits: ["hearts", "spades", "clubs", "diamonds"],
//     cards: Array(52),
//     createCardPicker: function() {
//         return ()=> {
//             let pickedCard = Math.floor(Math.random() * 52);
//             let pickedSuit = Math.floor(pickedCard / 13);

//             return {suit: this.suits[pickedSuit], card: pickedCard % 13};
//         }
//     }
// }

// let cardPicker = deck.createCardPicker();
// let pickedCard = cardPicker();

// alert("card: " + pickedCard.card + " of " + pickedCard.suit);


// interface UIElement {
//     addClickListener(onclick: (s: number, e: number) => void): void;
// }
// let dd:UIElement={
//     addClickListener:((s)=>{
//         s(1,1)
//     })
    
// }


// function ss<T>(ss:T):T{
//     return ss}
//     let dd:(ss:string):string= ss


// function identity<T>(arg: T[]): T[] {
//     return arg;
// }

// identity<string|Number>(["11,","111",1])


// interface GenericIdentityFn<T> {
//     (arg: T): T;
// }

// function identity<T>(arg: T): T {
//     return arg;
// }
// identity(1)
// let myIdentity: GenericIdentityFn<number>

// myIdentity=function(a){
//     return 1
// }

// // myIdentity(1)
// interface Lengthwise {
//     length: number;
// }

// function loggingIdentity<T extends Lengthwise>(arg: T): T {
//     console.log(arg.length);  // Now we know it has a .length property, so no more error
//     return arg;
// }
// loggingIdentity({ff:20length: 10});

// class BeeKeeper {
//     hasMask!: boolean;
// }

// class ZooKeeper {
//     nametag!: string;
// }

// class Animal {
//     numLegs!: number;
// }

// class Bee extends Animal {
//     keeper!: BeeKeeper;
// }

// class Lion extends Animal {
//     keeper!: ZooKeeper;
// }

// function createInstance<A extends Animal>(c: new () => A): A {
//     return new c();
// }

// createInstance(Lion).keeper.nametag;  // typechecks!
// createInstance(Bee).keeper.hasMask;   // typechecks!


// function pluck<T, K extends keyof T>(o: T, names: K[]): T[K][] {
//     return names.map(n => o[n]);
//   }
  
//   interface Person {
//       name: string;
//       age: number;
//   }
//   let person: Person = {
//       name: 'Jarid',
//       age: 35
//   };
//   let strings: string[] = pluck(person, ['name']); // ok, string[]
// let ss:number=1
// console.log(ss)

// type Easing = "ease-in" | "ease-out" | "ease-in-out";
// class UIElement {
//     animate(dx: number, dy: number, easing: Easing) {
//         if (easing === "ease-in") {
//             // ...
//         }
//         else if (easing === "ease-out") {
//         }
//         else if (easing === "ease-in-out") {
//         }
//         else {
//             // error! should not pass null or undefined.
//         }
//     }
// }

// let button = new UIElement();
// button.animate(0, 0, "ease-in");
// button.animate(0, 0, "uneasy"); // error: "uneasy" is not allowed here


// interface Square {
//     kind: "square";
//     size: number;
// }
// interface Rectangle {
//     kind: "rectangle";
//     width: number;
//     height: number;
// }
// interface Circle {
//     kind: "circle";
//     radius: number;
// }

// type Shape = Square | Rectangle | Circle;

// function area(s:Shape) {
//     switch (s.kind) {
//         case "square": return s.size * s.size;
//         case "rectangle": return s.height * s.width;
//         case "circle": return Math.PI * s.radius ** 2;
//     }
// }

// interface Square{
//     kind: "circle";
// }
// let ss:Square={
//     kind:"circle",
    
// }
// area(ss)

// interface Map1<T> {
//     [key: string]: T;
// }
// let keys: keyof Map1<number>; // string
// let value: Map1<number>['foo']; // number



// type Pick1<T, K extends keyof T> = {
//     [P in K]: T[P];
// }
// type Record1<K extends string, T> = {
//     [P in K]: T;
// }

